home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 38 / Amiga Format CD38 (1999-03-15)(Future Publishing)(GB)(Track 1 of 3)[!][issue 1999-04].iso / -seriously_amiga- / programming / other / cyberxxxsrc / decoder / txt / decodeulti.c < prev    next >
C/C++ Source or Header  |  1999-02-08  |  35KB  |  1,024 lines
  1. /*
  2. sc:c/sc opt txt/DecodeULTI.c
  3. */
  4.  
  5. #include "Decode.h"
  6. #include "GlobalVars.h"
  7. #include "YUV.h"
  8.  
  9. #define ultiChromNorm 0
  10. #define ultiChromUniq 1
  11. #define ultiStream0 0x0
  12. #define ultiStream1 0x4
  13.  
  14. /* /// "ulti0000" */
  15. #define ulti0000(ip,CST,c0,c1,c2,c3,r_inc) { \
  16.   *ip++=(CST)c0; *ip++=(CST)c1; *ip++=(CST)c2; *ip=(CST)c3; ip+=r_inc; \
  17.   *ip++=(CST)c0; *ip++=(CST)c1; *ip++=(CST)c2; *ip=(CST)c3; ip+=r_inc; \
  18.   *ip++=(CST)c0; *ip++=(CST)c1; *ip++=(CST)c2; *ip=(CST)c3; ip+=r_inc; \
  19.   *ip++=(CST)c0; *ip++=(CST)c1; *ip++=(CST)c2; *ip=(CST)c3; }
  20. /* \\\ */
  21.  
  22. /* /// "ulti0225" */
  23. #define ulti0225(ip,CST,c0,c1,c2,c3,r_inc) { \
  24.   *ip++=(CST)c1; *ip++=(CST)c2; *ip++=(CST)c3; *ip=(CST)c3; ip+=r_inc; \
  25.   *ip++=(CST)c0; *ip++=(CST)c1; *ip++=(CST)c2; *ip=(CST)c3; ip+=r_inc; \
  26.   *ip++=(CST)c0; *ip++=(CST)c1; *ip++=(CST)c2; *ip=(CST)c3; ip+=r_inc; \
  27.   *ip++=(CST)c0; *ip++=(CST)c0; *ip++=(CST)c1; *ip=(CST)c2; }
  28. /* \\\ */
  29.  
  30. /* /// "ulti0450" */
  31. #define ulti0450(ip,CST,c0,c1,c2,c3,r_inc) { \
  32.   *ip++=(CST)c1; *ip++=(CST)c2; *ip++=(CST)c3; *ip=(CST)c3; ip+=r_inc; \
  33.   *ip++=(CST)c1; *ip++=(CST)c2; *ip++=(CST)c2; *ip=(CST)c3; ip+=r_inc; \
  34.   *ip++=(CST)c0; *ip++=(CST)c1; *ip++=(CST)c1; *ip=(CST)c2; ip+=r_inc; \
  35.   *ip++=(CST)c0; *ip++=(CST)c0; *ip++=(CST)c1; *ip=(CST)c2; }
  36. /* \\\ */
  37.  
  38. /* /// "ulti0675" */
  39. #define ulti0675(ip,CST,c0,c1,c2,c3,r_inc) { \
  40.   *ip++=(CST)c2; *ip++=(CST)c3; *ip++=(CST)c3; *ip=(CST)c3; ip+=r_inc; \
  41.   *ip++=(CST)c1; *ip++=(CST)c2; *ip++=(CST)c2; *ip=(CST)c3; ip+=r_inc; \
  42.   *ip++=(CST)c0; *ip++=(CST)c1; *ip++=(CST)c1; *ip=(CST)c2; ip+=r_inc; \
  43.   *ip++=(CST)c0; *ip++=(CST)c0; *ip++=(CST)c0; *ip=(CST)c1; }
  44. /* \\\ */
  45.  
  46. /* /// "ulti0900" */
  47. #define ulti0900(ip,CST,c0,c1,c2,c3,r_inc) { \
  48.   *ip++=(CST)c3; *ip++=(CST)c3; *ip++=(CST)c3; *ip=(CST)c3; ip+=r_inc; \
  49.   *ip++=(CST)c2; *ip++=(CST)c2; *ip++=(CST)c2; *ip=(CST)c2; ip+=r_inc; \
  50.   *ip++=(CST)c1; *ip++=(CST)c1; *ip++=(CST)c1; *ip=(CST)c1; ip+=r_inc; \
  51.   *ip++=(CST)c0; *ip++=(CST)c0; *ip++=(CST)c0; *ip=(CST)c0; }
  52. /* \\\ */
  53.  
  54. /* /// "ulti1125" */
  55. #define ulti1125(ip,CST,c0,c1,c2,c3,r_inc) { \
  56.   *ip++=(CST)c3; *ip++=(CST)c3; *ip++=(CST)c3; *ip=(CST)c2; ip+=r_inc; \
  57.   *ip++=(CST)c3; *ip++=(CST)c2; *ip++=(CST)c2; *ip=(CST)c1; ip+=r_inc; \
  58.   *ip++=(CST)c2; *ip++=(CST)c1; *ip++=(CST)c1; *ip=(CST)c0; ip+=r_inc; \
  59.   *ip++=(CST)c1; *ip++=(CST)c0; *ip++=(CST)c0; *ip=(CST)c0; }
  60. /* \\\ */
  61.  
  62. /* /// "ulti1350" */
  63. #define ulti1350(ip,CST,c0,c1,c2,c3,r_inc) { \
  64.   *ip++=(CST)c3; *ip++=(CST)c3; *ip++=(CST)c2; *ip=(CST)c2; ip+=r_inc; \
  65.   *ip++=(CST)c3; *ip++=(CST)c2; *ip++=(CST)c1; *ip=(CST)c1; ip+=r_inc; \
  66.   *ip++=(CST)c2; *ip++=(CST)c2; *ip++=(CST)c1; *ip=(CST)c0; ip+=r_inc; \
  67.   *ip++=(CST)c1; *ip++=(CST)c1; *ip++=(CST)c0; *ip=(CST)c0; }
  68. /* \\\ */
  69.  
  70. /* /// "ulti1575" */
  71. #define ulti1575(ip,CST,c0,c1,c2,c3,r_inc) { \
  72.   *ip++=(CST)c3; *ip++=(CST)c3; *ip++=(CST)c2; *ip=(CST)c1; ip+=r_inc; \
  73.   *ip++=(CST)c3; *ip++=(CST)c2; *ip++=(CST)c1; *ip=(CST)c0; ip+=r_inc; \
  74.   *ip++=(CST)c3; *ip++=(CST)c2; *ip++=(CST)c1; *ip=(CST)c0; ip+=r_inc; \
  75.   *ip++=(CST)c2; *ip++=(CST)c1; *ip++=(CST)c0; *ip=(CST)c0; }
  76. /* \\\ */
  77.  
  78. /* /// "ultiC2" */
  79. #define ultiC2(ip,flag,c0,c1,rinc) { \
  80.   *ip++=(flag&0x80)?(c1):(c0); \
  81.   *ip++=(flag&0x40)?(c1):(c0); \
  82.   *ip++=(flag&0x20)?(c1):(c0); \
  83.   *ip++=(flag&0x10)?(c1):(c0); \
  84.   ip+=rinc; \
  85.   *ip++=(flag&0x08)?(c1):(c0); \
  86.   *ip++=(flag&0x04)?(c1):(c0); \
  87.   *ip++=(flag&0x02)?(c1):(c0); \
  88.   *ip++=(flag&0x01)?(c1):(c0); \
  89. }
  90. /* \\\ */
  91.  
  92. /* /// "ultiC4" */
  93. #define ultiC4(ip,CST,c0,c1,c2,c3,r_inc) { \
  94.   *ip++=(CST)c0; *ip++=(CST)c0; *ip++=(CST)c1; *ip=(CST)c1; ip+=r_inc; \
  95.   *ip++=(CST)c0; *ip++=(CST)c0; *ip++=(CST)c1; *ip=(CST)c1; ip+=r_inc; \
  96.   *ip++=(CST)c2; *ip++=(CST)c2; *ip++=(CST)c3; *ip=(CST)c3; ip+=r_inc; \
  97.   *ip++=(CST)c2; *ip++=(CST)c2; *ip++=(CST)c3; *ip=(CST)c3; }
  98. /* \\\ */
  99.  
  100. /* /// "ultirgbC2" */
  101. #define ultirgbC2(p,msk,clr0,clr1,rinc) { \
  102.  *p++=(msk & 0x80) ? clr1 : clr0;         \
  103.  *p++=(msk & 0x40) ? clr1 : clr0;         \
  104.  *p++=(msk & 0x20) ? clr1 : clr0;         \
  105.  *p++=(msk & 0x10) ? clr1 : clr0;         \
  106.  p+=rinc;                                 \
  107.  *p++=(msk & 0x08) ? clr1 : clr0;         \
  108.  *p++=(msk & 0x04) ? clr1 : clr0;         \
  109.  *p++=(msk & 0x02) ? clr1 : clr0;         \
  110.  *p++=(msk & 0x01) ? clr1 : clr0;         \
  111. }
  112. /* \\\ */
  113.  
  114. /* /// "blockInc" */
  115. #define blockInc(x,y,w) { x+=8; \
  116.                           if (x>=w) { \
  117.                             x=0; \
  118.                             y+=8; \
  119.                           } \
  120.                         }
  121. /* \\\ */
  122.  
  123. struct UltiData {
  124.   uchar *ltcTab;
  125.   long cr[16];
  126.   long cb[16];
  127.   long crcb[256];
  128. };
  129.  
  130. /* /// "GetULTIColorRGB" */
  131. #define GetULTIColorRGB(lum,chrom,tripl) {              \
  132.   ulong cr, cb;                                         \
  133.   long tlum=lum<<14;                                    \
  134.   cb=(chrom>>4) & 0x0f;                                 \
  135.   cr=chrom & 0x0f;                                      \
  136.   tripl.alpha=0;                                        \
  137.   tripl.red=rngLimit[(tlum+spec->cr[cr]) >> 12];        \
  138.   tripl.green=rngLimit[(tlum+spec->crcb[chrom]) >> 12]; \
  139.   tripl.blue=rngLimit[(tlum+spec->cb[cb]) >> 12];       \
  140. }
  141. /* \\\ */
  142.  
  143. /* /// "UltiLTCtoRGB()" */
  144. void UltiLTCtoRGB(RGBTriple *ip,
  145.                   ulong rinc,
  146.                   ulong y0,
  147.                   ulong y1,
  148.                   ulong y2,
  149.                   ulong y3,
  150.                   ulong chrom,
  151.                   ulong angle,
  152.                   struct UltiData *spec)
  153. {
  154.   ulong i;
  155.   RGBTriple t[4];
  156.   uchar idx[16];
  157.   uchar *ix;
  158.  
  159.   if (angle & 0x08) {
  160.     angle &= 0x07;
  161.     GetULTIColorRGB(y3,chrom,t[0]);
  162.     GetULTIColorRGB(y2,chrom,t[1]);
  163.     GetULTIColorRGB(y1,chrom,t[2]);
  164.     GetULTIColorRGB(y0,chrom,t[3]);
  165.   } else {
  166.     GetULTIColorRGB(y0,chrom,t[0]);
  167.     if (y1==y0) t[1]=t[0];
  168.     else GetULTIColorRGB(y1,chrom,t[1]);
  169.     if (y2==y1) t[2]=t[1];
  170.     else GetULTIColorRGB(y2,chrom,t[2]);
  171.     if (y3==y2) t[3]=t[2];
  172.     else GetULTIColorRGB(y3,chrom,t[3]);
  173.   }
  174.   ix=idx;
  175.   switch (angle) {
  176.     case 0: ulti0000(ix,uchar,0,1,2,3,1); break;
  177.     case 1: ulti0225(ix,uchar,0,1,2,3,1); break;
  178.     case 2: ulti0450(ix,uchar,0,1,2,3,1); break;
  179.     case 3: ulti0675(ix,uchar,0,1,2,3,1); break;
  180.     case 4: ulti0900(ix,uchar,0,1,2,3,1); break;
  181.     case 5: ulti1125(ix,uchar,0,1,2,3,1); break;
  182.     case 6: ulti1350(ix,uchar,0,1,2,3,1); break;
  183.     case 7: ulti1575(ix,uchar,0,1,2,3,1); break;
  184.     default: ultiC4(ix,uchar,0,1,2,3,1); break;
  185.   }
  186.   ix=idx;
  187.   for (i=0; i<16; i++) {
  188.     *ip++=t[*ix++];
  189.     if ((i & 3)==3) ip+=rinc;
  190.   }
  191. }
  192. /* \\\ */
  193.  
  194. /* /// "DecodeULTItoRGB()" */
  195. __asm void DecodeULTItoRGB(REG(a0) uchar *from,
  196.                            REG(a1) uchar *to,
  197.                            REG(d0) ulong width,
  198.                            REG(d1) ulong height,
  199.                            REG(d2) ulong encSize,
  200.                            REG(a2) struct UltiData *spec)
  201. {
  202.   ulong rinc=width-4; // (width-4)*4;
  203.   ulong exitflag=0;
  204.   long blockCnt=((width*height)>>6)+1;
  205.   long x=0;
  206.   long y=0;
  207.   RGBTriple *iptr;
  208.   ulong streamMode=ultiStream0;
  209.   ulong chromMode=ultiChromNorm;
  210.   ulong chromNextUniq=0;
  211.   ulong bhedr;
  212.   ulong opcode;
  213.   ulong chrom;
  214.  
  215.   while (!exitflag) {
  216.     bhedr=*from++;
  217.     if ((y>height) || (blockCnt<0)) {
  218.       exitflag=1;
  219.       continue;
  220.     } else if ((bhedr & 0xf8)==0x70) {
  221.       switch (bhedr) {
  222.         case 0x70: {
  223.                      ulong d;
  224.                      d=*from++;
  225.                      streamMode=(d==0)?(ultiStream0):(ultiStream1);
  226.                    }
  227.                    break;
  228.         case 0x71: chromNextUniq=1;
  229.                    break;
  230.         case 0x72: /* chromMode=(chromMode==ultiChromNorm)?(ultiChromUniq):(ultiChromNorm); */
  231.                    chromMode^=1;
  232.                    break;
  233.         case 0x73: exitflag=1;
  234.                    break;
  235.         case 0x74: {
  236.                      ulong cnt;
  237.                      cnt=*from++;
  238.                      blockCnt-=cnt;
  239.                      while (cnt--) blockInc(x,y,width);
  240.                    }
  241.                    break;
  242.  
  243.         default: exitflag=1;
  244.                  break;
  245.       }
  246.     } else {
  247.       ulong chromFlag;
  248.       ulong quadrant;
  249.       ulong msh;
  250.  
  251.       blockCnt--;
  252.       if ((chromMode==ultiChromUniq) || (chromNextUniq)) {
  253.         chromNextUniq=0;
  254.         chromFlag=1;
  255.         chrom=0;
  256.       } else {
  257.         chromFlag=0;
  258.         if (bhedr!=0x00) chrom=*from++;
  259.       }
  260.       msh=8;
  261.       for (quadrant=0; quadrant<4; quadrant++) {
  262.         ulong tx, ty;
  263.         if (quadrant==0) { tx=x; ty=y; }
  264.         else if (quadrant==1) ty+=4;
  265.         else if (quadrant==2) tx+=4;
  266.         else ty-=4;
  267.         iptr=(RGBTriple *)(to+(ty*width+tx)*4);
  268.         msh-=2;
  269.         opcode=((bhedr>>msh) & 0x03) | streamMode;
  270.         switch (opcode) {
  271.           case 0x04:
  272.           case 0x00: break;
  273.  
  274.           case 0x05:
  275.           case 0x01: {
  276.                        ulong angle;
  277.                        ulong y0, y1;
  278.                        if (chromFlag) chrom=*from++;
  279.                        y0=*from++;
  280.                        angle=(y0>>6) & 0x03;
  281.                        y0 &= 0x3f;
  282.                        if (angle==0) {
  283.                          UltiLTCtoRGB(iptr,rinc,y0,y0,y0,y0,chrom,angle,spec);
  284.                        } else {
  285.                          y1=y0+1;
  286.                          if (y1>63) y1=63;
  287.                          if (angle==3) angle=12;
  288.                          else if (angle==2) angle=6;
  289.                          else angle=2;
  290.                          UltiLTCtoRGB(iptr,rinc,y0,y0,y1,y1,chrom,angle,spec);
  291.                        }
  292.                      }
  293.                      break;
  294.  
  295.           case 0x02: {
  296.                        ulong angle;
  297.                        ulong ltcIdx;
  298.                        ulong y0, y1, y2, y3;
  299.                        uchar *tmp;
  300.                        if (chromFlag) chrom=*from++;
  301.                        ltcIdx=get16(from);
  302.                        angle=(ltcIdx>>12) & 0x0f;
  303.                        ltcIdx=(ltcIdx & 0x0fff)<<2;
  304.                        tmp=&(spec->ltcTab[ltcIdx]);
  305.                        y0=tmp[0];
  306.                        y1=tmp[1];
  307.                        y2=tmp[2];
  308.                        y3=tmp[3];
  309.                        UltiLTCtoRGB(iptr,rinc,y0,y1,y2,y3,chrom,angle,spec);
  310.                      }
  311.                      break;
  312.  
  313.           case 0x03: {
  314.                        ulong d;
  315.                        if (chromFlag) chrom=*from++;
  316.                        d=*from++;
  317.                        if (d & 0x80) {
  318.                          ulong angle;
  319.                          ulong y0, y1, y2, y3;
  320.                          angle=(d>>4) & 0x07;
  321.                          d=(d<<8) | (from[0]);
  322.                          y0=(d>>6) & 0x3f;
  323.                          y1=d & 0x3f;
  324.                          y2=(from[1]) & 0x3f;
  325.                          y3=(from[2]) & 0x3f;
  326.                          from+=3;
  327.                          UltiLTCtoRGB(iptr,rinc,y0,y1,y2,y3,chrom,angle,spec);
  328.                        } else {
  329.                          ulong y0, y1;
  330.                          uchar flag0, flag1;
  331.                          RGBTriple t0, t1;
  332.                          uchar r0, r1, g0, g1, b0, b1;
  333.                          flag0=from[0];
  334.                          flag1=d;
  335.                          y0=(from[1]) & 0x3f;
  336.                          y1=(from[2]) & 0x3f;
  337.                          from+=3;
  338.                          GetULTIColorRGB(y0,chrom,t0);
  339.                          GetULTIColorRGB(y1,chrom,t1);
  340.                          ultirgbC2(iptr,flag1,t0,t1,rinc); iptr+=rinc;
  341.                          ultirgbC2(iptr,flag0,t0,t1,rinc);
  342.                        }
  343.                      }
  344.                      break;
  345.  
  346.           case 0x06: {
  347.                        ulong y0, y1, y2, y3;
  348.                        if (chromFlag) chrom=*from++;
  349.                        y3=get24(from);
  350.                        y0=(y3>>18) & 0x3f;
  351.                        y1=(y3>>12) & 0x3f;
  352.                        y2=(y3>>6) & 0x3f;
  353.                        y3 &= 0x3f;
  354.                        UltiLTCtoRGB(iptr,rinc,y0,y1,y2,y3,chrom,0x10,spec);
  355.                      }
  356.                      break;
  357.  
  358.           case 0x07: {
  359.                        ulong i, d, y[16];
  360.                        if (chromFlag) chrom=*from++;
  361.                        d=get24(from);
  362.                        i=0;
  363.                        y[i++]=(d>>18) & 0x3f;
  364.                        y[i++]=(d>>12) & 0x3f;
  365.                        y[i++]=(d>>6) & 0x3f;
  366.                        y[i++]=d & 0x3f;
  367.                        d=get24(from);
  368.                        y[i++]=(d>>18) & 0x3f;
  369.                        y[i++]=(d>>12) & 0x3f;
  370.                        y[i++]=(d>>6) & 0x3f;
  371.                        y[i++]=d & 0x3f;
  372.                        d=get24(from);
  373.                        y[i++]=(d>>18) & 0x3f;
  374.                        y[i++]=(d>>12) & 0x3f;
  375.                        y[i++]=(d>>6) & 0x3f;
  376.                        y[i++]=d & 0x3f;
  377.                        d=get24(from);
  378.                        y[i++]=(d>>18) & 0x3f;
  379.                        y[i++]=(d>>12) & 0x3f;
  380.                        y[i++]=(d>>6) & 0x3f;
  381.                        y[i  ]=d & 0x3f;
  382.                        for (i=0; i<16; i++) {
  383.                          GetULTIColorRGB(y[i],chrom,*iptr);
  384.                          iptr++;
  385.                          if ((i%4)==3) iptr+=rinc;
  386.                        }
  387.                      }
  388.                      break;
  389.           default: break;
  390.         }
  391.       }
  392.       blockInc(x,y,width);
  393.     }
  394.   }
  395. }
  396. /* \\\ */
  397.  
  398. /* /// "GetULTIColor332" */
  399. #define GetULTIColor332(lum,chrom,color)       \
  400. {                                              \
  401.   /* für Graustufen nur Luminanz kopieren */   \
  402.   /* color=lum<<2; */                          \
  403.   ulong cr, cb, ra, ga, ba;                    \
  404.   long tlum=lum<<14;                           \
  405.   cb=(chrom>>4) & 0x0f;                        \
  406.   cr=chrom & 0x0f;                             \
  407.   ra=rngLimit[(tlum+spec->cr[cr]) >> 12];      \
  408.   ga=rngLimit[(tlum+spec->crcb[chrom]) >> 12]; \
  409.   ba=rngLimit[(tlum+spec->cb[cb]) >> 12];      \
  410.   color=RGBtoCol332(ra,ga,ba,scale8);          \
  411. }                                              \
  412. /* \\\ */
  413.  
  414. /* früher
  415.   tmp=(tlum+spec->cr[cr])>>14;                       \
  416.   if (tmp<0) tmp=0; else if (tmp>63) tmp=63; ra=tmp; \
  417.   tmp=(tlum+spec->cb[cb])>>14;                       \
  418.   if (tmp<0) tmp=0; else if (tmp>63) tmp=63; ba=tmp; \
  419.   tmp=(tlum+spec->crcb[chrom])>>14;                  \
  420.   if (tmp<0) tmp=0; else if (tmp>63) tmp=63; ga=tmp; \
  421.   color=RGBtoCol332(ra,ga,ba,scale6);                \
  422. */
  423.  
  424. /* /// "UltiLTCto332()" */
  425. void UltiLTCto332(uchar *ip,
  426.                   ulong rinc,
  427.                   ulong y0,
  428.                   ulong y1,
  429.                   ulong y2,
  430.                   ulong y3,
  431.                   ulong chrom,
  432.                   ulong angle,
  433.                   struct UltiData *spec)
  434. {
  435.   ulong c0, c1, c2, c3;
  436.  
  437.   if (angle & 0x08) {
  438.     angle &= 0x07;
  439.     GetULTIColor332(y3,chrom,c0);
  440.     GetULTIColor332(y2,chrom,c1);
  441.     GetULTIColor332(y1,chrom,c2);
  442.     GetULTIColor332(y0,chrom,c3);
  443.   } else {
  444.     GetULTIColor332(y0,chrom,c0);
  445.     if (y1==y0) c1=c0;
  446.     else GetULTIColor332(y1,chrom,c1);
  447.     if (y2==y1) c2=c1;
  448.     else GetULTIColor332(y2,chrom,c2);
  449.     if (y3==y2) c3=c2;
  450.     else GetULTIColor332(y3,chrom,c3);
  451.   }
  452.   switch(angle) {
  453.     case 0: ulti0000(ip,uchar,c0,c1,c2,c3,rinc); break;
  454.     case 1: ulti0225(ip,uchar,c0,c1,c2,c3,rinc); break;
  455.     case 2: ulti0450(ip,uchar,c0,c1,c2,c3,rinc); break;
  456.     case 3: ulti0675(ip,uchar,c0,c1,c2,c3,rinc); break;
  457.     case 4: ulti0900(ip,uchar,c0,c1,c2,c3,rinc); break;
  458.     case 5: ulti1125(ip,uchar,c0,c1,c2,c3,rinc); break;
  459.     case 6: ulti1350(ip,uchar,c0,c1,c2,c3,rinc); break;
  460.     case 7: ulti1575(ip,uchar,c0,c1,c2,c3,rinc); break;
  461.     default: ultiC4(ip,uchar,c0,c1,c2,c3,rinc); break;
  462.   }
  463. }
  464. /* \\\ */
  465.  
  466. /* /// "DecodeULTIto332()" */
  467. __asm void DecodeULTIto332(REG(a0) uchar *from,
  468.                            REG(a1) uchar *to,
  469.                            REG(d0) ulong width,
  470.                            REG(d1) ulong height,
  471.                            REG(d2) ulong encSize,
  472.                            REG(a2) struct UltiData *spec)
  473. {
  474.   ulong rinc=width-3;
  475.   ulong exitflag=0;
  476.   long blockCnt=((width*height)>>6)+1;
  477.   long x=0;
  478.   long y=0;
  479.   uchar *iptr;
  480.   ulong streamMode=ultiStream0;
  481.   ulong chromMode=ultiChromNorm;
  482.   ulong chromNextUniq=0;
  483.   ulong bhedr;
  484.   ulong opcode;
  485.   ulong chrom;
  486.  
  487.   while (!exitflag) {
  488.     bhedr=*from++;
  489.     if ((y>height) || (blockCnt<0)) {
  490.       exitflag=1;
  491.       continue;
  492.     } else if ((bhedr & 0xf8)==0x70) {
  493.       switch (bhedr) {
  494.         case 0x70: {
  495.                      ulong d;
  496.                      d=*from++;
  497.                      streamMode=(d==0)?(ultiStream0):(ultiStream1);
  498.                    }
  499.                    break;
  500.         case 0x71: chromNextUniq=1;
  501.                    break;
  502.         case 0x72: /* chromMode=(chromMode==ultiChromNorm)?(ultiChromUniq):(ultiChromNorm); */
  503.                    chromMode^=1;
  504.                    break;
  505.         case 0x73: exitflag=1;
  506.                    break;
  507.         case 0x74: {
  508.                      ulong cnt;
  509.                      cnt=*from++;
  510.                      blockCnt-=cnt;
  511.                      while (cnt--) blockInc(x,y,width);
  512.                    }
  513.                    break;
  514.  
  515.         default: exitflag=1;
  516.                  break;
  517.       }
  518.     } else {
  519.       ulong chromFlag;
  520.       ulong quadrant;
  521.       ulong msh;
  522.  
  523.       blockCnt--;
  524.       if ((chromMode==ultiChromUniq) || (chromNextUniq)) {
  525.         chromNextUniq=0;
  526.         chromFlag=1;
  527.         chrom=0;
  528.       } else {
  529.         chromFlag=0;
  530.         if (bhedr!=0x00) chrom=*from++;
  531.       }
  532.       msh=8;
  533.       for(quadrant=0; quadrant<4; quadrant++) {
  534.         ulong tx,ty;
  535.         if (quadrant==0) { tx=x; ty=y; }
  536.         else if (quadrant==1) ty+=4;
  537.         else if (quadrant==2) tx+=4;
  538.         else ty-=4;
  539.         iptr=(to+(ty*width+tx));
  540.         msh-=2;
  541.         opcode=((bhedr>>msh) & 0x03) | streamMode;
  542.         switch (opcode) {
  543.           case 0x04:
  544.           case 0x00: break;
  545.  
  546.           case 0x05:
  547.           case 0x01: {
  548.                        ulong angle;
  549.                        ulong y0,y1;
  550.                        if (chromFlag) chrom=*from++;
  551.                        y0=*from++;
  552.                        angle=(y0>>6) & 0x03;
  553.                        y0 &= 0x3f;
  554.                        if (angle==0) {
  555.                          UltiLTCto332(iptr,rinc,y0,y0,y0,y0,chrom,angle,spec);
  556.                        } else {
  557.                          y1=y0+1;
  558.                          if (y1>63) y1=63;
  559.                          if (angle==3) angle=12;
  560.                          else if (angle==2) angle=6;
  561.                          else angle=2;
  562.                          UltiLTCto332(iptr,rinc,y0,y0,y1,y1,chrom,angle,spec);
  563.                        }
  564.                      }
  565.                      break;
  566.  
  567.           case 0x02: {
  568.                        ulong angle;
  569.                        ulong ltcIdx;
  570.                        ulong y0,y1,y2,y3;
  571.                        uchar *tmp;
  572.                        if (chromFlag) chrom=*from++;
  573.                        ltcIdx=get16(from);
  574.                        angle=(ltcIdx>>12) & 0x0f;
  575.                        ltcIdx=(ltcIdx & 0x0fff)<<2;
  576.                        tmp=&(spec->ltcTab[ltcIdx]);
  577.                        y0=tmp[0];
  578.                        y1=tmp[1];
  579.                        y2=tmp[2];
  580.                        y3=tmp[3];
  581.                        UltiLTCto332(iptr,rinc,y0,y1,y2,y3,chrom,angle,spec);
  582.                      }
  583.                      break;
  584.  
  585.           case 0x03: {
  586.                        ulong d;
  587.                        if (chromFlag) chrom=*from++;
  588.                        d=*from++;
  589.                        if (d & 0x80) {
  590.                          ulong angle;
  591.                          ulong y0,y1,y2,y3;
  592.                          angle=(d>>4) & 0x07;
  593.                          d=(d<<8) | (from[0]);
  594.                          y0=(d>>6) & 0x3f;
  595.                          y1=d & 0x3f;
  596.                          y2=(from[1]) & 0x3f;
  597.                          y3=(from[2]) & 0x3f;
  598.                          from+=3;
  599.                          UltiLTCto332(iptr,rinc,y0,y1,y2,y3,chrom,angle,spec);
  600.                        } else {
  601.                          ulong y0,y1;
  602.                          uchar flag0,flag1;
  603.                          ulong c0,c1;
  604.                          ulong trinc=rinc-1;
  605.                          flag0=from[0];
  606.                          flag1=d;
  607.                          y0=(from[1]) & 0x3f;
  608.                          y1=(from[2]) & 0x3f;
  609.                          from+=3;
  610.                          GetULTIColor332(y0,chrom,c0);
  611.                          GetULTIColor332(y1,chrom,c1);
  612.                          ultiC2(iptr,flag1,c0,c1,trinc); iptr+=trinc;
  613.                          ultiC2(iptr,flag0,c0,c1,trinc);
  614.                        }
  615.                      }
  616.                      break;
  617.  
  618.           case 0x06: {
  619.                        ulong y0,y1,y2,y3;
  620.                        if (chromFlag) chrom=*from++;
  621.                        y3=get24(from);
  622.                        y0=(y3>>18) & 0x3f;
  623.                        y1=(y3>>12) & 0x3f;
  624.                        y2=(y3>>6) & 0x3f;
  625.                        y3 &= 0x3f;
  626.                        UltiLTCto332(iptr,rinc,y0,y1,y2,y3,chrom,0x10,spec);
  627.                      }
  628.                      break;
  629.  
  630.           case 0x07: {
  631.                        ulong i,d,y[16];
  632.                        ulong trinc=rinc-1;
  633.                        if (chromFlag) chrom=*from++;
  634.                        d=get24(from);
  635.                        i=0;
  636.                        y[i++]=(d>>18) & 0x3f;
  637.                        y[i++]=(d>>12) & 0x3f;
  638.                        y[i++]=(d>>6) & 0x3f;
  639.                        y[i++]=d & 0x3f;
  640.                        d=get24(from);
  641.                        y[i++]=(d>>18) & 0x3f;
  642.                        y[i++]=(d>>12) & 0x3f;
  643.                        y[i++]=(d>>6) & 0x3f;
  644.                        y[i++]=d & 0x3f;
  645.                        d=get24(from);
  646.                        y[i++]=(d>>18) & 0x3f;
  647.                        y[i++]=(d>>12) & 0x3f;
  648.                        y[i++]=(d>>6) & 0x3f;
  649.                        y[i++]=d & 0x3f;
  650.                        d=get24(from);
  651.                        y[i++]=(d>>18) & 0x3f;
  652.                        y[i++]=(d>>12) & 0x3f;
  653.                        y[i++]=(d>>6) & 0x3f;
  654.                        y[i  ]=d & 0x3f;
  655.                        for(i=0; i<16; i++) {
  656.                          GetULTIColor332(y[i],chrom,*iptr);
  657.                          iptr++;
  658.                          if ((i%4)==3) iptr+=trinc;
  659.                        }
  660.                      }
  661.                      break;
  662.           default: break;
  663.         }
  664.       }
  665.       blockInc(x,y,width);
  666.     }
  667.   }
  668. }
  669. /* \\\ */
  670.  
  671. /* /// "ulti0000dith" */
  672. #define ulti0000dith(r_inc) { \
  673.   *ip++=c0; *ip++=d1; *ip++=c2; *ip=d3; ip+=r_inc; \
  674.   *ip++=d0; *ip++=c1; *ip++=d2; *ip=c3; ip+=r_inc; \
  675.   *ip++=c0; *ip++=d1; *ip++=c2; *ip=d3; ip+=r_inc; \
  676.   *ip++=d0; *ip++=c1; *ip++=d2; *ip=c3; }
  677. /* \\\ */
  678.  
  679. /* /// "ulti0225dith" */
  680. #define ulti0225dith(r_inc) { \
  681.   *ip++=c1; *ip++=d2; *ip++=c3; *ip=d3; ip+=r_inc; \
  682.   *ip++=d0; *ip++=c1; *ip++=d2; *ip=c3; ip+=r_inc; \
  683.   *ip++=c0; *ip++=d1; *ip++=c2; *ip=d3; ip+=r_inc; \
  684.   *ip++=d0; *ip++=c0; *ip++=d1; *ip=c2; }
  685. /* \\\ */
  686.  
  687. /* /// "ulti0450dith" */
  688. #define ulti0450dith(r_inc) { \
  689.   *ip++=c1; *ip++=d2; *ip++=c3; *ip=d3; ip+=r_inc; \
  690.   *ip++=d1; *ip++=c2; *ip++=d2; *ip=c3; ip+=r_inc; \
  691.   *ip++=c0; *ip++=d1; *ip++=c1; *ip=d2; ip+=r_inc; \
  692.   *ip++=d0; *ip++=c0; *ip++=d1; *ip=c2; }
  693. /* \\\ */
  694.  
  695. /* /// "ulti0675dith" */
  696. #define ulti0675dith(r_inc) { \
  697.   *ip++=c2; *ip++=d3; *ip++=c3; *ip=d3; ip+=r_inc; \
  698.   *ip++=d1; *ip++=c2; *ip++=d2; *ip=c3; ip+=r_inc; \
  699.   *ip++=c0; *ip++=d1; *ip++=c1; *ip=d2; ip+=r_inc; \
  700.   *ip++=d0; *ip++=c0; *ip++=d0; *ip=c1; }
  701. /* \\\ */
  702.  
  703. /* /// "ulti0900dith" */
  704. #define ulti0900dith(r_inc) { \
  705.   *ip++=c3; *ip++=d3; *ip++=c3; *ip=d3; ip+=r_inc; \
  706.   *ip++=d2; *ip++=c2; *ip++=d2; *ip=c2; ip+=r_inc; \
  707.   *ip++=c1; *ip++=d1; *ip++=c1; *ip=d1; ip+=r_inc; \
  708.   *ip++=d0; *ip++=c0; *ip++=d0; *ip=c0; }
  709. /* \\\ */
  710.  
  711. /* /// "ulti1125dith" */
  712. #define ulti1125dith(r_inc) { \
  713.   *ip++=c3; *ip++=d3; *ip++=c3; *ip=d2; ip+=r_inc; \
  714.   *ip++=d3; *ip++=c2; *ip++=d2; *ip=c1; ip+=r_inc; \
  715.   *ip++=c2; *ip++=d1; *ip++=c1; *ip=d0; ip+=r_inc; \
  716.   *ip++=d1; *ip++=c0; *ip++=d0; *ip=c0; }
  717. /* \\\ */
  718.  
  719. /* /// "ulti1350dith" */
  720. #define ulti1350dith(r_inc) { \
  721.   *ip++=c3; *ip++=d3; *ip++=c2; *ip=d2; ip+=r_inc; \
  722.   *ip++=d3; *ip++=c2; *ip++=d1; *ip=c1; ip+=r_inc; \
  723.   *ip++=c2; *ip++=d2; *ip++=c1; *ip=d0; ip+=r_inc; \
  724.   *ip++=d1; *ip++=c1; *ip++=d0; *ip=c0; }
  725. /* \\\ */
  726.  
  727. /* /// "ulti1575dith" */
  728. #define ulti1575dith(r_inc) { \
  729.   *ip++=c3; *ip++=d3; *ip++=c2; *ip=d1; ip+=r_inc; \
  730.   *ip++=d3; *ip++=c2; *ip++=d1; *ip=c0; ip+=r_inc; \
  731.   *ip++=c3; *ip++=d2; *ip++=c1; *ip=d0; ip+=r_inc; \
  732.   *ip++=d2; *ip++=c1; *ip++=d0; *ip=c0; }
  733. /* \\\ */
  734.  
  735. /* /// "ultiC2dith" */
  736. #define ultiC2dith(ip,flag,c0,c1,d0,d1,rinc) { \
  737.   *ip++=(flag&0x80)?(c1):(c0); \
  738.   *ip++=(flag&0x40)?(d1):(d0); \
  739.   *ip++=(flag&0x20)?(c1):(c0); \
  740.   *ip++=(flag&0x10)?(d1):(d0); \
  741.   ip+=rinc; \
  742.   *ip++=(flag&0x08)?(d1):(d0); \
  743.   *ip++=(flag&0x04)?(c1):(c0); \
  744.   *ip++=(flag&0x02)?(d1):(d0); \
  745.   *ip++=(flag&0x01)?(c1):(c0); \
  746. }
  747. /* \\\ */
  748.  
  749. /* /// "ultiC4dith" */
  750. #define ultiC4dith(r_inc) { \
  751.   *ip++=c0; *ip++=d0; *ip++=c1; *ip=d1; ip+=r_inc; \
  752.   *ip++=d0; *ip++=c0; *ip++=d1; *ip=c1; ip+=r_inc; \
  753.   *ip++=c2; *ip++=d2; *ip++=c3; *ip=d3; ip+=r_inc; \
  754.   *ip++=d2; *ip++=c2; *ip++=d3; *ip=c3; }
  755. /* \\\ */
  756.  
  757. /* /// "GetULTIColor332Dith" */
  758. #define GetULTIColor332Dith(lum,chrom,col1,col2)          \
  759. {                                                         \
  760.   ulong cr, cb, ra, ga, ba;                               \
  761.   long tlum=lum<<14;                                      \
  762.   cb=(chrom>>4) & 0x0f;                                   \
  763.   cr=chrom & 0x0f;                                        \
  764.   ra=rngLimit[(tlum+spec->cr[cr]) >> 12];                 \
  765.   ga=rngLimit[(tlum+spec->crcb[chrom]) >> 12];            \
  766.   ba=rngLimit[(tlum+spec->cb[cb]) >> 12];                 \
  767.   DitherGetRGB(ra,ga,ba,re,ge,be,col1);                   \
  768.   DitherGetRGB(ra,ga,ba,re,ge,be,col2);                   \
  769. }                                                         \
  770. /* \\\ */
  771.  
  772. /* /// "UltiLTCto332Dith()" */
  773. void UltiLTCto332Dith(uchar *ip,
  774.                       ulong rinc,
  775.                       ulong y0,
  776.                       ulong y1,
  777.                       ulong y2,
  778.                       ulong y3,
  779.                       ulong chrom,
  780.                       ulong angle,
  781.                       struct UltiData *spec)
  782. {
  783.   ulong c0, c1, c2, c3;
  784.   ulong d0, d1, d2, d3;
  785.   long re=0, ge=0, be=0;
  786.  
  787.   if (angle & 0x08) {
  788.     angle &= 0x07;
  789.     GetULTIColor332Dith(y3,chrom,c0,d0);
  790.     GetULTIColor332Dith(y2,chrom,c1,d1);
  791.     GetULTIColor332Dith(y1,chrom,c2,d2);
  792.     GetULTIColor332Dith(y0,chrom,c3,d3);
  793.   } else {
  794.     GetULTIColor332Dith(y0,chrom,c0,d0);
  795.     if (y1==y0) {c1=c0; d1=d0;}
  796.     else GetULTIColor332Dith(y1,chrom,c1,d1);
  797.     if (y2==y1) {c2=c1; d2=d1;}
  798.     else GetULTIColor332Dith(y2,chrom,c2,d2);
  799.     if (y3==y2) {c3=c2; d3=d2;}
  800.     else GetULTIColor332Dith(y3,chrom,c3,d3);
  801.   }
  802.   /* c0=c1=c2=c3=d0=d1=d2=d3=0; */
  803.   switch(angle) {
  804.     case 0: ulti0000dith(rinc); break;
  805.     case 1: ulti0225dith(rinc); break;
  806.     case 2: ulti0450dith(rinc); break;
  807.     case 3: ulti0675dith(rinc); break;
  808.     case 4: ulti0900dith(rinc); break;
  809.     case 5: ulti1125dith(rinc); break;
  810.     case 6: ulti1350dith(rinc); break;
  811.     case 7: ulti1575dith(rinc); break;
  812.     default: ultiC4dith(rinc); break;
  813.   }
  814. }
  815. /* \\\ */
  816.  
  817. /* /// "DecodeULTIto332Dith()" */
  818. __asm void DecodeULTIto332Dith(REG(a0) uchar *from,
  819.                                REG(a1) uchar *to,
  820.                                REG(d0) ulong width,
  821.                                REG(d1) ulong height,
  822.                                REG(d2) ulong encSize,
  823.                                REG(a2) struct UltiData *spec)
  824. {
  825.   ulong rinc=width-3;
  826.   ulong exitflag=0;
  827.   long blockCnt=((width*height)>>6)+1;
  828.   long x=0;
  829.   long y=0;
  830.   uchar *iptr;
  831.   ulong streamMode=ultiStream0;
  832.   ulong chromMode=ultiChromNorm;
  833.   ulong chromNextUniq=0;
  834.   ulong bhedr;
  835.   ulong opcode;
  836.   ulong chrom;
  837.  
  838.   while (!exitflag) {
  839.     bhedr=*from++;
  840.     if ((y>height) || (blockCnt<0)) {
  841.       exitflag=1;
  842.       continue;
  843.     } else if ((bhedr & 0xf8)==0x70) {
  844.       switch (bhedr) {
  845.         case 0x70: {
  846.                      ulong d;
  847.                      d=*from++;
  848.                      streamMode=(d==0)?(ultiStream0):(ultiStream1);
  849.                    }
  850.                    break;
  851.         case 0x71: chromNextUniq=1;
  852.                    break;
  853.         case 0x72: /* chromMode=(chromMode==ultiChromNorm)?(ultiChromUniq):(ultiChromNorm); */
  854.                    chromMode^=1;
  855.                    break;
  856.         case 0x73: exitflag=1;
  857.                    break;
  858.         case 0x74: {
  859.                      ulong cnt;
  860.                      cnt=*from++;
  861.                      blockCnt-=cnt;
  862.                      while (cnt--) blockInc(x,y,width);
  863.                    }
  864.                    break;
  865.  
  866.         default: exitflag=1;
  867.                  break;
  868.       }
  869.     } else {
  870.       ulong chromFlag;
  871.       ulong quadrant;
  872.       ulong msh;
  873.  
  874.       blockCnt--;
  875.       if ((chromMode==ultiChromUniq) || (chromNextUniq)) {
  876.         chromNextUniq=0;
  877.         chromFlag=1;
  878.         chrom=0;
  879.       } else {
  880.         chromFlag=0;
  881.         if (bhedr!=0x00) chrom=*from++;
  882.       }
  883.       msh=8;
  884.       for(quadrant=0; quadrant<4; quadrant++) {
  885.         ulong tx,ty;
  886.         if (quadrant==0) { tx=x; ty=y; }
  887.         else if (quadrant==1) ty+=4;
  888.         else if (quadrant==2) tx+=4;
  889.         else ty-=4;
  890.         iptr=(to+(ty*width+tx));
  891.         msh-=2;
  892.         opcode=((bhedr>>msh) & 0x03) | streamMode;
  893.         switch (opcode) {
  894.           case 0x04:
  895.           case 0x00: break;
  896.  
  897.           case 0x05:
  898.           case 0x01: {
  899.                        ulong angle;
  900.                        ulong y0,y1;
  901.                        if (chromFlag) chrom=*from++;
  902.                        y0=*from++;
  903.                        angle=(y0>>6) & 0x03;
  904.                        y0 &= 0x3f;
  905.                        if (angle==0) {
  906.                          UltiLTCto332Dith(iptr,rinc,y0,y0,y0,y0,chrom,angle,spec);
  907.                        } else {
  908.                          y1=y0+1;
  909.                          if (y1>63) y1=63;
  910.                          if (angle==3) angle=12;
  911.                          else if (angle==2) angle=6;
  912.                          else angle=2;
  913.                          UltiLTCto332Dith(iptr,rinc,y0,y0,y1,y1,chrom,angle,spec);
  914.                        }
  915.                      }
  916.                      break;
  917.  
  918.           case 0x02: {
  919.                        ulong angle;
  920.                        ulong ltcIdx;
  921.                        ulong y0,y1,y2,y3;
  922.                        uchar *tmp;
  923.                        if (chromFlag) chrom=*from++;
  924.                        ltcIdx=get16(from);
  925.                        angle=(ltcIdx>>12) & 0x0f;
  926.                        ltcIdx=(ltcIdx & 0x0fff)<<2;
  927.                        tmp=&(spec->ltcTab[ltcIdx]);
  928.                        y0=tmp[0];
  929.                        y1=tmp[1];
  930.                        y2=tmp[2];
  931.                        y3=tmp[3];
  932.                        UltiLTCto332Dith(iptr,rinc,y0,y1,y2,y3,chrom,angle,spec);
  933.                      }
  934.                      break;
  935.  
  936.           case 0x03: {
  937.                        ulong d;
  938.                        if (chromFlag) chrom=*from++;
  939.                        d=*from++;
  940.                        if (d & 0x80) {
  941.                          ulong angle;
  942.                          ulong y0,y1,y2,y3;
  943.                          angle=(d>>4) & 0x07;
  944.                          d=(d<<8) | (from[0]);
  945.                          y0=(d>>6) & 0x3f;
  946.                          y1=d & 0x3f;
  947.                          y2=(from[1]) & 0x3f;
  948.                          y3=(from[2]) & 0x3f;
  949.                          from+=3;
  950.                          UltiLTCto332Dith(iptr,rinc,y0,y1,y2,y3,chrom,angle,spec);
  951.                        } else {
  952.                          ulong y0,y1;
  953.                          uchar flag0,flag1;
  954.                          ulong c0, c1, d0, d1;
  955.                          ulong trinc=rinc-1;
  956.                          long re=0, ge=0, be=0;
  957.                          flag0=from[0];
  958.                          flag1=d;
  959.                          y0=(from[1]) & 0x3f;
  960.                          y1=(from[2]) & 0x3f;
  961.                          from+=3;
  962.                          GetULTIColor332Dith(y0,chrom,c0,d0);
  963.                          GetULTIColor332Dith(y1,chrom,c1,d1);
  964.                          ultiC2dith(iptr,flag1,c0,c1,d0,d1,trinc); iptr+=trinc;
  965.                          ultiC2dith(iptr,flag0,c0,c1,d0,d1,trinc);
  966.                        }
  967.                      }
  968.                      break;
  969.  
  970.           case 0x06: {
  971.                        ulong y0,y1,y2,y3;
  972.                        if (chromFlag) chrom=*from++;
  973.                        y3=get24(from);
  974.                        y0=(y3>>18) & 0x3f;
  975.                        y1=(y3>>12) & 0x3f;
  976.                        y2=(y3>>6) & 0x3f;
  977.                        y3 &= 0x3f;
  978.                        UltiLTCto332Dith(iptr,rinc,y0,y1,y2,y3,chrom,0x10,spec);
  979.                      }
  980.                      break;
  981.  
  982.           case 0x07: {
  983.                        ulong i,d,y[16];
  984.                        ulong trinc=rinc-1;
  985.                        long re=0, ge=0, be=0;
  986.                        if (chromFlag) chrom=*from++;
  987.                        d=get24(from);
  988.                        i=0;
  989.                        y[i++]=(d>>18) & 0x3f;
  990.                        y[i++]=(d>>12) & 0x3f;
  991.                        y[i++]=(d>>6) & 0x3f;
  992.                        y[i++]=d & 0x3f;
  993.                        d=get24(from);
  994.                        y[i++]=(d>>18) & 0x3f;
  995.                        y[i++]=(d>>12) & 0x3f;
  996.                        y[i++]=(d>>6) & 0x3f;
  997.                        y[i++]=d & 0x3f;
  998.                        d=get24(from);
  999.                        y[i++]=(d>>18) & 0x3f;
  1000.                        y[i++]=(d>>12) & 0x3f;
  1001.                        y[i++]=(d>>6) & 0x3f;
  1002.                        y[i++]=d & 0x3f;
  1003.                        d=get24(from);
  1004.                        y[i++]=(d>>18) & 0x3f;
  1005.                        y[i++]=(d>>12) & 0x3f;
  1006.                        y[i++]=(d>>6) & 0x3f;
  1007.                        y[i  ]=d & 0x3f;
  1008.                        for(i=0; i<16; i++) {
  1009.                          GetULTIColor332Dith(y[i],chrom,*iptr,d);
  1010.                          iptr++;
  1011.                          if ((i%4)==3) iptr+=trinc;
  1012.                        }
  1013.                      }
  1014.                      break;
  1015.           default: break;
  1016.         }
  1017.       }
  1018.       blockInc(x,y,width);
  1019.     }
  1020.   }
  1021. }
  1022. /* \\\ */
  1023.  
  1024.